{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": false,
        "id": "XLjsvhkuS2eJ"
      },
      "source": [
        "# Learning to Invert Heat Conduction with Scale-invariant Updates\n",
        "\n",
        "We now turn to a practical example that use the scale-invariant physics (SIP) updates in a more complex example. Specifically, we'll consider the heat equation, which poses some particularly interesting challenges: the differentiable physics (DP) gradient just diffuses more, while the inversion is numerically challenging. Below, we'll explain how SIPs adress the former, while a special solver can address the latter issue.\n",
        "\n",
        "The notebook below provides a full implementation via _phiflow_ to generate data, run the DP version, and compute the improved SIP updates.\n",
        "[[run in colab]](https://colab.research.google.com/github/tum-pbs/pbdl-book/blob/main/physgrad-code.ipynb)\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9fETS9hwrQrc"
      },
      "source": [
        "## Problem Statement\n",
        "\n",
        "We consider a two-dimensional system governed by the heat equation $\\frac{\\partial u}{\\partial t} = \\nu \\cdot \\nabla^2 u$.\n",
        "Given an initial state $x = u(t_0)$ at $t_0$, the simulator computes the state at a later time $t_*$ via $y = u(t_*) = \\mathcal P(x)$.\n",
        "Exactly inverting this system is only possible for $t \\cdot \\nu = 0$ and becomes increasingly unstable for larger $t \\cdot \\nu$ because initially distinct heat levels even out over time, drowning the original information in noise.\n",
        "Hence the Jacobian of the physics $\\frac{\\partial y}{\\partial x}$ is near-singular.\n",
        "\n",
        "We'll use periodic boundary conditions and compute the result in frequency space where the physics can be computed analytically as $\\hat y = \\hat x \\cdot e^{-k^2 (t_* - t_0)} $ , where $\\hat y_k \\equiv \\mathcal F(y)_k$ denotes the $k$-th element of the Fourier-transformed vector $y$.\n",
        "In the regular _forward_ simulation, high frequencies are dampened exponentially. We'll need to revisit this aspect for the inverse simulator.\n",
        "\n",
        "To summarize, the inverse problem we're targeting here can be written as minimizing:\n",
        "\n",
        "$$L(x) = || \\mathcal P(x) - y^* ||_2^2 = || \\mathcal F^{-1}\\left( \\mathcal F(x) \\cdot e^{-k^2 (t_* - t_0)} \\right) - y^* ||_2^2 . $$\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EA7qc5mXsZLU"
      },
      "source": [
        "---\n",
        "\n",
        "## Implementation\n",
        "\n",
        "Below, we'll set $t\\cdot \\nu = 8$ on a domain consisting of 64x64 cells of unit length.\n",
        "This level of diffusion is challenging, and diffuses most details while leaving only the large-scale structure intact.\n",
        "\n",
        "We'll use phiflow with PyTorch as default backend, but this example code likewise runs with TensorFlow (just switch to `phi.tf.flow` below).\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "vN06frDqS2eM",
        "pycharm": {
          "name": "#%%\n"
        },
        "outputId": "fa9def4f-2b3c-4ed8-a7c7-b1927e3e8299",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[?25l     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/182.2 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m182.2/182.2 kB\u001b[0m \u001b[31m9.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25h  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m306.1/306.1 kB\u001b[0m \u001b[31m18.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25h  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Building wheel for phiflow (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Building wheel for phiml (setup.py) ... \u001b[?25l\u001b[?25hdone\n"
          ]
        }
      ],
      "source": [
        "!pip install --upgrade --quiet phiflow==3.1\n",
        "from phi.torch.flow import *    # switch to TF with \"phi.tf.flow\""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": false,
        "id": "fc6Am-XcS2eN"
      },
      "source": [
        "\n",
        "## Data generation\n",
        "\n",
        "For training, we generate $x^*$ by randomly placing between 4 and 10 \"hot\" rectangles of random size and shape in the domain. The `generate_heat_example()` function below generates a full mini batch (via `shape.batch`) of example positions. These will be $x$ later on. They're never passed to the solver, but should be reconstructed by the neural network.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "-39wQc1ES2eN",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [],
      "source": [
        "def generate_heat_example(*shape, bounds: Box = None):\n",
        "    shape = math.merge_shapes(*shape)\n",
        "    heat_t0 = CenteredGrid(0, extrapolation.PERIODIC, bounds, resolution=shape.spatial)\n",
        "    bounds = heat_t0.bounds\n",
        "    component_counts = math.to_int32(4 + 7 * math.random_uniform(shape.batch))\n",
        "    positions = (math.random_uniform(shape.batch, batch(components=10), channel(vector=shape.spatial.names)) - 0.5) * bounds.size * 0.8 + bounds.size * 0.5\n",
        "    for i in range(10):\n",
        "        position = positions.components[i]\n",
        "        half_size = math.random_uniform(shape.batch, channel(vector=shape.spatial.names)) * 10\n",
        "        strength = math.random_uniform(shape.batch) * math.to_float(i < component_counts)\n",
        "        position = math.clip(position, bounds.lower + half_size, bounds.upper - half_size)\n",
        "        component_box = Cuboid(position, half_size)\n",
        "        component_mask = SoftGeometryMask(component_box)\n",
        "        component_mask = component_mask.at(heat_t0)\n",
        "        heat_t0 += component_mask * strength\n",
        "    return heat_t0"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": false,
        "id": "sz_eZyZ7S2eO"
      },
      "source": [
        "The data is generated on-the-fly later during training, but let's look at two example $x$ for now using phiflow's `vis.plot` function:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 546
        },
        "id": "BHtnPdL3S2eO",
        "outputId": "cdd6105f-51ef-44e4-ca8c-70da6cb9bb08",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-2-350e9b9c59ed>:13: DeprecationWarning: HardGeometryMask and SoftGeometryMask are deprecated. Use field.mask or field.resample instead.\n",
            "  component_mask = SoftGeometryMask(component_box)\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1200x500 with 4 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "vis.plot(generate_heat_example(batch(view_examples=2), spatial(x=64, y=64)));"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": false,
        "id": "XURdC4v_S2eP"
      },
      "source": [
        "\n",
        "## Differentiable physics and gradient descent\n",
        "\n",
        "Nothing in this setup so far prevents us from using regular DP training, as described in {doc}`diffphys`.\n",
        "For this diffusion case, we can write out\n",
        "gradient descent update from in an analytic fashion as:\n",
        "$$\\Delta x_{\\text{GD}} = - \\eta \\cdot \\mathcal F^{-1}\\left( e^{-k^2 (t_* - t_0)} \\mathcal F(y - y^*) \\right).$$\n",
        "\n",
        "Looking at this expression, it means that gradient descent (GD) with the gradient from the differentiable simulator applies the forward physics to the gradient vector itself. This is surprising: the forward simulation performs diffusion, and now the backward pass performs even more of it, instead of somehow undoing the diffusion? Unfortunately, this is the inherent and \"correct\" behavior of DP, and it results in updates that are stable but lack high frequency spatial information.\n",
        "\n",
        "Consequently, GD-based optimization methods converge slowly on this task after fitting the coarse structure and have severe problems in recovering high-frequency details, as will be demonstrated below.\n",
        "This is not because the information is fundamentally missing but because GD cannot adequately process high-frequency details.\n",
        "\n",
        "For the implementation below, we will simply use `y = diffuse.fourier(x, 8., 1)` for the forward pass, and then similarly compute an $L^2$ loss for two $y$ fields to which `diffuse.fourier( , 8., 1)` is applied.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EUIM1Av5vlfR"
      },
      "source": [
        "## Stable SIP gradients\n",
        "\n",
        "What is more interesting in the context of this chapter is the improved update step computed via the inverse simulator, the _SIP_ update. In line with the previous sections, we'll call this update $\\Delta x_{\\text{PG}}.$\n",
        "\n",
        "The frequency formulation of the heat equation can be inverted analytically, yielding\n",
        "$\\hat x_k = \\hat y_k \\cdot e^{k^2 (t_* - t_0)}$.\n",
        "This allows us to define the update\n",
        "\n",
        "$$\\Delta x_{\\text{PG}} = - \\eta \\cdot \\mathcal F^{-1}\\left( e^{k^2 (t_* - t_0)} \\mathcal F(y - y^*) \\right).$$\n",
        "\n",
        "Here, high frequencies are multiplied by exponentially large factors, resulting in numerical instabilities.\n",
        "When applying this formula directly to the gradients, it can lead to large oscillations in $\\Delta x_{\\text{PG}}$.\n",
        "\n",
        "Note that these numerical instabilities also occur when computing the gradients in real space instead of frequency space.\n",
        "However, frequency space allows us to more easily quantify them.\n",
        "\n",
        "Now we can leverage our knowledge of the physical simulation process to construct a stable inverse:\n",
        "the numerical instabilities can be avoided by taking a probabilistic viewpoint.\n",
        "The observed values $y$ contain a certain amount of noise $n$, with the remainder constituting the signal $s = y - n$.\n",
        "For the noise, we assume a normal distribution $n \\sim \\mathcal N(0, \\epsilon \\cdot y)$ with $\\epsilon > 0$ and for the signal, we assume that it arises from reasonable values of $x$ so that $y \\sim \\mathcal N(0, \\delta \\cdot e^{-k^2})$ with $\\delta > 0$.\n",
        "With this, we can estimate the probability of an observed value arising from the signal using Bayes' theorem\n",
        "$p(s | v) = \\frac{p(v | s) \\cdot p(s)}{p(v | s) \\cdot p(s) + p(v | n) \\cdot p(n)}$ where we assume the priors $p(s) = p(n) = \\frac 1 2$.\n",
        "Based on this probability, we dampen the amplification of the inverse physics which yields a stable inverse.\n",
        "\n",
        "Gradients computed in this way hold as much high-frequency information as can be extracted given the noise that is present.\n",
        "This leads to a much faster convergence and more precise solution than any generic optimization method.\n",
        "The cell below implements this probabilistic approach, with `probability_signal` in `apply_damping()` containing the parts of the signal to be dampened.\n",
        "The `inv_diffuse()` functions employs it to compute a stabilized inverse diffusion process.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "jJFlJlRwS2eP",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [],
      "source": [
        "def apply_damping(kernel, inv_kernel, amp, f_uncertainty, log_kernel):\n",
        "    signal_prior = 0.5\n",
        "    expected_amp = 1. * kernel.shape.get_size('x') * inv_kernel  # This can be measured\n",
        "    signal_likelihood = math.exp(-0.5 * (abs(amp) / expected_amp) ** 2) * signal_prior  # this can be NaN\n",
        "    signal_likelihood = math.where(math.isfinite(signal_likelihood), signal_likelihood, math.zeros_like(signal_likelihood))\n",
        "    noise_likelihood = math.exp(-0.5 * (abs(amp) / f_uncertainty) ** 2) * (1 - signal_prior)\n",
        "    probability_signal = math.divide_no_nan(signal_likelihood, (signal_likelihood + noise_likelihood))\n",
        "    action = math.where((0.5 >= probability_signal) | (probability_signal >= 0.68), 2 * (probability_signal - 0.5), 0.)  # 1 sigma required to take action\n",
        "    prob_kernel = math.exp(log_kernel * action)\n",
        "    return prob_kernel, probability_signal\n",
        "\n",
        "\n",
        "def inv_diffuse(grid: Grid, amount: float, uncertainty: Grid):\n",
        "    f_uncertainty: math.Tensor = math.sqrt(math.sum(uncertainty.values ** 2, dim='x,y'))  # all frequencies have the same uncertainty, 1/N in iFFT\n",
        "    k_squared: math.Tensor = math.sum(math.fftfreq(grid.shape, grid.dx) ** 2, 'vector')\n",
        "    fft_laplace: math.Tensor = -(2 * np.pi) ** 2 * k_squared\n",
        "    # --- Compute sharpening kernel with damping ---\n",
        "    log_kernel = fft_laplace * -amount\n",
        "    log_kernel_clamped = math.minimum(log_kernel, math.to_float(math.floor(math.log(math.wrap(np.finfo(np.float32).max)))))  # avoid overflow\n",
        "    raw_kernel = math.exp(log_kernel_clamped)  # inverse diffusion FFT kernel, all values >= 1\n",
        "    inv_kernel = math.exp(-log_kernel)\n",
        "    amp = math.fft(grid.values)\n",
        "    kernel, sig_prob = apply_damping(raw_kernel, inv_kernel, amp, f_uncertainty, log_kernel)\n",
        "    # --- Apply and compute uncertainty ---\n",
        "    data = math.real(math.ifft(amp * math.to_complex(kernel)))\n",
        "    uncertainty = math.sqrt(math.sum(((f_uncertainty * kernel) ** 2))) / grid.shape.get_size('x')  # 1/N normalization in iFFT\n",
        "    uncertainty = grid * 0 + uncertainty\n",
        "    return grid.with_values(data), uncertainty, abs(amp), raw_kernel, kernel, sig_prob"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": false,
        "id": "Prft7mS6S2eQ"
      },
      "source": [
        "## Neural network and loss function\n",
        "\n",
        "For the neural network, we use a simple U-net architecture for the SIP and the regular DP+Adam version (in line with the previous sections, we'll denote it as `GD`).\n",
        "We train with a batch size of 128 and a constant learning rate of $\\eta = 10^{-3}$, using 64 bit precision for physics but 32 bits for the network.\n",
        "The network updates are computed with TensorFlow's or PyTorch's automatic differentiation.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "edLI4HnjS2eR",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [],
      "source": [
        "math.set_global_precision(64)\n",
        "BATCH = batch(batch=128)\n",
        "STEPS = 50\n",
        "\n",
        "math.seed(0)\n",
        "net = u_net(1, 1)\n",
        "optimizer = adam(net, 0.001)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": false,
        "id": "lkkXZc_kS2eR"
      },
      "source": [
        "Now we'll define loss function for phiflow.\n",
        "The gradients for the network weights are always computed as d(loss_function)/d$\\theta$.\n",
        "\n",
        "For SIP, we invert the physics, and then define the proxy loss as $L^2$(prediction - correction), where correction is taken as constant. Below this is realized via `x = field.stop_gradient(prediction)`. This L2 loss triggers the backprop towards the neural network weights. For SIP, the `y_l2` is only computed for comparison, and is not crucial for training.\n",
        "\n",
        "The Adam / GD version for `sip=False` simply computes the L2 difference of the predicted, diffused $y$ field to the target, and backprops through the operations for the gradient.\n",
        "\n",
        "We also compute the reference $y = \\mathcal P(x^*)$ in the loss function on-the-fly.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "aUKHZMwkS2eR",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [],
      "source": [
        "# @math.jit_compile\n",
        "def loss_function(net, x_gt: CenteredGrid, sip: bool):\n",
        "    y_target = diffuse.fourier(x_gt, 8., 1)\n",
        "    with math.precision(32):\n",
        "        prediction = field.native_call(net, field.to_float(y_target)).vector[0]\n",
        "        prediction += field.mean(x_gt) - field.mean(prediction)\n",
        "    x = field.stop_gradient(prediction)\n",
        "    if sip:\n",
        "        y = diffuse.fourier(x, 8., 1)\n",
        "        dx, _, amp, raw_kernel, kernel, sig_prob = inv_diffuse(y_target - y, 8., uncertainty=abs(y_target - y) * 1e-6)\n",
        "        correction = x + dx\n",
        "        y_l2 = field.l2_loss(y - y_target)  # not important, just for tracking\n",
        "        loss = field.l2_loss(prediction - correction) # proxy L2 loss for network\n",
        "    else:\n",
        "        y = diffuse.fourier(prediction, 8., 1)\n",
        "        loss = y_l2 = field.l2_loss(y - y_target) # for Adam we backprop through the loss and y\n",
        "    return loss, x, y, field.l2_loss(x_gt - x), y_l2\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": false,
        "id": "0L142o1OS2eS"
      },
      "source": [
        "## Training\n",
        "\n",
        "In the training loop, we generate data on-the-fly via `generate_heat_example()` and use phiflow's `update_weights()` function to call the correct functions of the chosen backend. Note that we're only printing the loss of the first 5 steps below for clarity, the whole history is collected in the `loss_` lists. The following cell runs the SIP version of the training:\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PK47PUNKaeA0",
        "outputId": "ce7f8d7b-bfd8-4884-85e1-786d4b3d0f39"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-2-350e9b9c59ed>:13: DeprecationWarning: HardGeometryMask and SoftGeometryMask are deprecated. Use field.mask or field.resample instead.\n",
            "  component_mask = SoftGeometryMask(component_box)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "SIP L2 loss x ; y: 185.01902418878524 ; 52.86203787432579\n",
            "SIP L2 loss x ; y: 80.09229485521256 ; 13.743946340489366\n",
            "SIP L2 loss x ; y: 51.198420978751095 ; 4.212126705173006\n",
            "SIP L2 loss x ; y: 51.166816963598585 ; 3.871802844235444\n",
            "SIP L2 loss x ; y: 41.97257479831386 ; 3.3333446973370604\n"
          ]
        }
      ],
      "source": [
        "loss_sip_x=[]; loss_sip_y=[]\n",
        "for training_step in range(STEPS):\n",
        "    data = generate_heat_example(spatial(x=64, y=64), BATCH)\n",
        "    loss_value, x_sip, y_sip, x_l2, y_l2 = update_weights(net, optimizer, loss_function, net, data, sip=True)\n",
        "    loss_sip_x.append(float(x_l2.mean))\n",
        "    loss_sip_y.append(float(y_l2.mean))\n",
        "    if(training_step<5): print(\"SIP L2 loss x ; y: \"+format(float(x_l2.mean))+\" ; \"+format(float(y_l2.mean)) )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "32HFjc2y7noA"
      },
      "source": [
        "And now we can repeat the training with the DP version using Adam, deactivating the SIP update via `sip=False`:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0ENSdgZiS2eS",
        "outputId": "ecf7e415-3329-4c19-fa9f-2db6f765008c",
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-2-350e9b9c59ed>:13: DeprecationWarning: HardGeometryMask and SoftGeometryMask are deprecated. Use field.mask or field.resample instead.\n",
            "  component_mask = SoftGeometryMask(component_box)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "GD L2 loss x ; y: 185.01902418878524 ; 52.86203787432579\n",
            "GD L2 loss x ; y: 111.90876514444714 ; 19.610744935770025\n",
            "GD L2 loss x ; y: 67.98615290073411 ; 5.831835761821972\n",
            "GD L2 loss x ; y: 74.69661928237372 ; 11.433268852185064\n",
            "GD L2 loss x ; y: 52.55936273792499 ; 4.227996622501346\n"
          ]
        }
      ],
      "source": [
        "math.seed(0)\n",
        "net_gd = u_net(1, 1)\n",
        "optimizer_gd = adam(net_gd, 0.001)\n",
        "\n",
        "loss_gd_x=[]; loss_gd_y=[]\n",
        "for training_step in range(STEPS):\n",
        "    data = generate_heat_example(spatial(x=64, y=64), BATCH)\n",
        "    loss_value, x_gd, y_gd, x_l2, y_l2 = update_weights(net_gd, optimizer_gd, loss_function, net_gd, data, sip=False)\n",
        "    loss_gd_x.append(float(x_l2.mean))\n",
        "    loss_gd_y.append(float(y_l2.mean))\n",
        "    if(training_step<5): print(\"GD L2 loss x ; y: \"+format(float(x_l2.mean))+\" ; \"+format(float(y_l2.mean)) )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eV1j8lYuwUqB"
      },
      "source": [
        "## Evaluation\n",
        "\n",
        "Now we can evaluate how the two variants behave in direct comparison. Note that due to the on-the-fly generation of randomized data, all samples are previously unseen, and hence we'll directly use the training curves here to draw  conclusions about the performance of the two approaches.\n",
        "\n",
        "The following graph shows the $L^2$ error over training in terms of the reconstructed $x$ input, the main goal of our training."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 449
        },
        "id": "uUkHS8Xljn7O",
        "outputId": "9e74d72c-31b9-46c7-ab2f-09ecad2141ae"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "import pylab as plt\n",
        "fig = plt.figure().gca()\n",
        "pltx = range(len(loss_gd_x))\n",
        "fig.plot(pltx, loss_gd_x , lw=2, color='blue',      label=\"GD\")\n",
        "fig.plot(pltx, loss_sip_x  , lw=2, color='red', label=\"SIP\")\n",
        "plt.xlabel('iterations'); plt.ylabel('x loss'); plt.legend(); plt.yscale(\"log\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-ZIRzk7ZwZ2x"
      },
      "source": [
        "The log-scale for the loss in $x$ nicely highlights that the SIP version does inherently better, and shows a significantly improved convergence for the NN training. This is purely caused by the better signal for the physics via the proxy loss. As shown in `loss_function()`, both variants use the same backprop-based update to change the weights of the NN. The improvements purely stem from the higher-order step in $y$ space computed by the inverse simulator.\n",
        "\n",
        "Just out of curiosity, we can also compare how the two versions compare in terms of difference in the output space $y$."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 537
        },
        "id": "KcJemrzNu6dm",
        "outputId": "e2bb1f74-91e4-49a7-efb9-e2c0e8e5c9a7"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-10-63a3d36fc9b2>:4: DeprecationWarning: Please import `gaussian_filter1d` from the `scipy.ndimage` namespace; the `scipy.ndimage.filters` namespace is deprecated and will be removed in SciPy 2.0.0.\n",
            "  fig.plot(pltx, scipy.ndimage.filters.gaussian_filter1d(loss_gd_y,sigma=2)  , lw=2, color='blue',      label=\"GD\")\n",
            "<ipython-input-10-63a3d36fc9b2>:5: DeprecationWarning: Please import `gaussian_filter1d` from the `scipy.ndimage` namespace; the `scipy.ndimage.filters` namespace is deprecated and will be removed in SciPy 2.0.0.\n",
            "  fig.plot(pltx, scipy.ndimage.filters.gaussian_filter1d(loss_sip_y ,sigma=2), lw=2, color='red', label=\"SIP\")\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "fig = plt.figure().gca()\n",
        "pltx = range(len(loss_gd_y))\n",
        "import scipy # for filtering\n",
        "fig.plot(pltx, scipy.ndimage.filters.gaussian_filter1d(loss_gd_y,sigma=2)  , lw=2, color='blue',      label=\"GD\")\n",
        "fig.plot(pltx, scipy.ndimage.filters.gaussian_filter1d(loss_sip_y ,sigma=2), lw=2, color='red', label=\"SIP\")\n",
        "plt.xlabel('iterations'); plt.ylabel('y loss'); plt.legend(); plt.yscale(\"log\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DeSQEpHB0Tip"
      },
      "source": [
        "There's likewise an improvements for SIPs, but it is not as pronounced as in $x$ space. Luckily, the $x$ reconstruction is the primary target, and hence of higher importance for the inverse problem at hand.\n",
        "\n",
        "The differences in terms of $L^2$ error are also very obvious in direct comparison. The following cell plots a reconstruction from GD & Adam next to the SIP version, and the ground truth on the right. The difference is obvious: the SIP reconstruction is significantly sharper, and contains fewer halos than the GD version. This is a direct consequence of the undesirable behavior of GD applying diffusion to the backpropagated gradient, instead of working against it."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 430
        },
        "id": "gNvf0FuxwfdF",
        "outputId": "4843e33e-dc42-481e-e433-2c75bb42401b"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1500x400 with 6 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "pltv = vis.plot(x_gd.values.batch[0], x_sip.values.batch[0], data.values.batch[0], size=(15,4) )\n",
        "pltv.axes[0].set_title(\"Adam\"); pltv.axes[1].set_title(\"SIP\"); pltv.axes[2].set_title(\"Reference\");"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pC5xFvjv7wGz"
      },
      "source": [
        "## Next steps\n",
        "\n",
        "* For this example, it's worth experimenting with various training parameters: run the training longer, with varying learning rates, and different network sizes (or even different architectures).\n"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "name": "Heat-SIP-forPBDL.ipynb",
      "provenance": [],
      "machine_shape": "hm",
      "gpuType": "A100"
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 2
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython2",
      "version": "2.7.6"
    },
    "accelerator": "GPU"
  },
  "nbformat": 4,
  "nbformat_minor": 0
}